package lanQiaoBei.基础算法.离散化;

import java.util.*;
import java.io.*;
import java.util.stream.*;

/*
  离散化（整数有序）的核心思想：数据范围很大 但数据数量不多 可以考虑将数据离散化处理
* 以“区间和”题目为例
  假设有一个无限长的数轴，数轴上的每个坐标的数都是0
  现在，我们进行n次操作，每次操作将某一位置x的数加上c
  接下来进行m次询问，每次询问包含两个整数l和r，你需要求出l到r区间的所有和
  输入格式：
  n,m（-10^5~+10^5）
  n行 x(-无穷~+无穷),c
  m行 l,r（-无穷~+无穷）
  输出格式：
  m行 区间和
3 3
1 2
3 6
7 5
1 3
4 6
7 8
输出：
8
0
5
* */
public class P1 {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    final static int N = 100010, M = 300010;
    static int n, m, a[] = new int[M];
    static Pair[] add = new Pair[N], query = new Pair[N];
    static ArrayList<Integer> all = null;

    static void scan() throws Exception {
        String[] ss = br.readLine().split(" ");
        n = Integer.parseInt(ss[0]);
        m = Integer.parseInt(ss[1]);
        Set<Integer> set = new HashSet();
        for (int i = 0; i < n; i++) {
            ss = br.readLine().split(" ");
            int x = Integer.parseInt(ss[0]), c = Integer.parseInt(ss[1]);
            add[i] = new Pair(x, c);
            set.add(x);
        }
        for (int i = 0; i < m; i++) {
            ss = br.readLine().split(" ");
            int l = Integer.parseInt(ss[0]), r = Integer.parseInt(ss[1]);
            query[i] = new Pair(l, r);
            set.add(l);
            set.add(r);
        }
        all = (ArrayList) set.stream().sorted().collect(Collectors.toList());
    }

    static int mapping(int x) {
        int l = 0, r = all.size() - 1;
        while (l < r) {
            int mid = l + r >> 1;
            if (all.get(mid) >= x) r = mid;
            else l = mid + 1;
        }
        return l + 1;
    }

    public static void main(String[] args) throws Exception {
        scan();
        for (int i = 0; i < n; i++) {
            Pair pair = add[i];
            a[mapping(pair.first)] += pair.second;
        }
        for (int i = 1; i <= all.size(); i++) {
            a[i] = a[i - 1] + a[i];
        }
        for (int i = 0; i < m; i++) {
            Pair pair = query[i];
            int l = mapping(pair.first), r = mapping(pair.second);
            System.out.println(a[r] - a[l - 1]);
        }
    }
    static class Pair {
        int first;
        int second;
        Pair(int first, int second) {
            this.first = first;
            this.second = second;
        }
    }
}